package com.aps.orchestrator.selector;

import com.aps.algorithm.core.APSAlgorithm;
import com.aps.orchestrator.scenario.ProductionScenario;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.stream.Collectors;

/**
 * 算法选择器
 * 根据生产场景选择合适的算法
 */
@Slf4j
@Component
public class AlgorithmSelector {
    
    @Autowired
    private List<APSAlgorithm> availableAlgorithms;
    
    /**
     * 根据生产场景选择算法
     * @param scenario 生产场景
     * @return 选中的算法
     */
    public APSAlgorithm selectAlgorithm(ProductionScenario scenario) {
        log.info("开始为场景选择算法: {}", scenario.getDescription());
        
        // 根据场景复杂度选择算法
        if (scenario.isSimple()) {
            return selectSimpleAlgorithm(scenario);
        } else if (scenario.isComplex()) {
            return selectComplexAlgorithm(scenario);
        } else {
            return selectModerateAlgorithm(scenario);
        }
    }
    
    /**
     * 选择简单场景算法
     * @param scenario 生产场景
     * @return 算法
     */
    private APSAlgorithm selectSimpleAlgorithm(ProductionScenario scenario) {
        log.info("选择简单场景算法");
        
        // 简单场景优先使用关键比率算法
        return availableAlgorithms.stream()
            .filter(algorithm -> algorithm.getAlgorithmName().equals("CriticalRatio"))
            .findFirst()
            .orElseGet(() -> availableAlgorithms.get(0)); // 如果没有找到，返回第一个可用算法
    }
    
    /**
     * 选择中等场景算法
     * @param scenario 生产场景
     * @return 算法
     */
    private APSAlgorithm selectModerateAlgorithm(ProductionScenario scenario) {
        log.info("选择中等场景算法");
        
        // 中等场景可以使用关键比率算法或遗传算法
        List<APSAlgorithm> candidates = availableAlgorithms.stream()
            .filter(algorithm -> 
                algorithm.getAlgorithmName().equals("CriticalRatio") ||
                algorithm.getAlgorithmName().equals("GeneticAlgorithm"))
            .collect(Collectors.toList());
        
        if (!candidates.isEmpty()) {
            return candidates.get(0);
        }
        
        return availableAlgorithms.get(0);
    }
    
    /**
     * 选择复杂场景算法
     * @param scenario 生产场景
     * @return 算法
     */
    private APSAlgorithm selectComplexAlgorithm(ProductionScenario scenario) {
        log.info("选择复杂场景算法");
        
        // 复杂场景优先使用遗传算法
        return availableAlgorithms.stream()
            .filter(algorithm -> algorithm.getAlgorithmName().equals("GeneticAlgorithm"))
            .findFirst()
            .orElseGet(() -> availableAlgorithms.get(0));
    }
    
    /**
     * 获取所有可用算法
     * @return 算法列表
     */
    public List<APSAlgorithm> getAvailableAlgorithms() {
        return availableAlgorithms;
    }
    
    /**
     * 根据算法名称获取算法
     * @param algorithmName 算法名称
     * @return 算法
     */
    public APSAlgorithm getAlgorithmByName(String algorithmName) {
        return availableAlgorithms.stream()
            .filter(algorithm -> algorithm.getAlgorithmName().equals(algorithmName))
            .findFirst()
            .orElse(null);
    }
}
